Discussion: this makes me feel a bit uneasy, but I guess the logic here is: anything that's not the standard library should be considered a non-library artifact, and should be considered a product of the stage n (compiler, standard library) pair (and so gets numbered as the next stage)? I.e. reading back https://hackmd.io/QXj6LqntQTKPgm3uBuE-aA again, the core model is

stage corresponds to what gets built, not what is used to build it

(The following is me trying to make sure I understand this)

Let's call the (compiler, library) pair¹²

where the separation between stages is delineated by which $\mathrm{compiler}$ gets built. Then, by design, because the standard library is "special" and tightly coupled with the compiler, we fix the immediate standard library built by $\mathrm{compiler}_{\mathrm{stage}}$ to be of the same $\mathrm{stage}$, i.e. $\mathrm{library}_{\mathrm{stage}}$.

With the stage 0 redesign, we now have a nice straightforward "derivation chain" ($\longrightarrow$; artifacts can be used to build new artifacts) property where

actually holds even for $\mathrm{stage} = 0$.

However, for:

• bootstrap tools
  Tools that are unconditionally built by the stage 0 $\mathbf{CLP}$, i.e. always depends on $\mathbf{CLP}_{0}$. Their stage numbering will be called $\mathrm{BootstrapTool}_{1}$, at least in the short-term.
• host rustc tools
  Tools that depend on rustc_private and so on $\mathrm{compiler}_{\mathrm{stage}}$. This means that they will be numbered as $\mathrm{HostRustcTool}_{\mathrm{stage} + 1}$.
• std tools
  Tools that depend on the whole $\mathbf{CLP}_{\mathrm{stage}}$, i.e. both $\mathrm{compiler}_{\mathrm{stage}}$, and $\mathrm{library}_{\mathrm{stage}}$. Similiarly, this means that they will be numbered as $\mathrm{StdTool}_{\mathrm{stage} + 1}$.

They then follow the general "what gets built" model (?).

Question: wait, why is this different? For $\mathrm{stage} \ge 1$, isn't this equivalent? I.e.

At this point, wouldn't we have already rejected invoking ./x check flow with $\mathrm{stage} = 0$?

Equivalent to what? :) I changed it just to this:

let build_compiler = builder.compiler(builder.top_stage, host);
builder.ensure(Std::new(build_compiler, target));
build_compiler

because I remembered that stdlib's proc macros and build scripts are always compiled using the stage0 libstd. We only need the host stdlib when compiling host code of other modes (yeah, I know..).

Except! We actually need the host stdlib when checking the tool itself (not stdlib). Aaaaargh.

Equivalent to what?

NGL, I don't know what I meant by this myself -- when I click at this comment, it's outdated against something, and I can't tell what it was...

Suggestion: actually, can you add a comment for this specifically that we're exercising cross-compile here, so --stage 1 isn't sufficient?